<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<!-- <link href="../../css/jsoneditor/jsoneditor.css" rel="stylesheet" type="text/css"> -->
<script type="text/javascript" src="../../lib/innerIframe-include-ext.js"></script>
<script type="text/javascript" src="../../lib/loader-theme.js"></script>
<script type="text/javascript" src="../../lib/ext/locale/ext-lang-zh_CN.js"></script>
<script type="text/javascript" src="../../lib/ext/plugins/DataTip.js"></script>
<script type="text/javascript" src="../../js/moment.min.js"></script>
<script type="text/javascript" src="../../lib/dict.js"></script>
<!-- <script type="text/javascript" src="../../lib/jsoneditor/jsoneditor.js"></script>
<script type="text/javascript" src="../../lib/jsoneditor/ext-ux-jsoneditor.js"></script> -->
<title>积分规则管理</title>
</head>
<script type="text/javascript">
Ext.require(['*']);
Ext.onReady(function(){
    Ext.QuickTips.init();
    Ext.define('model', {
        extend: 'Ext.data.Model',
        fields: [
            'id','rule_id','rule_name','rule_type','app_id','status','begin_date','end_date','expiry_date',
            'period_day','amount','frequency','frequency_unit','prompt','remark','priority','cond_type',
            'condition','create_at','update_at','vendor'
        ],
        idProperty: 'id'
    });
    
    var store = Ext.create('Ext.data.Store', {
        pageSize: 15,
        model: 'model',
        remoteSort: true,
        proxy: {
            type: 'ajax',
            method: 'GET',
            url: '/rule/list',
            reader: {
                type: 'json',
                root: 'data',
                totalProperty: 'count'
            },
            simpleSortMode: true
        },
        sorters: [
            {
                property: 'id',
                direction: 'DESC'
            }
        ]
    });

    var appStore_search = Ext.create('Ext.data.JsonStore',{
        fields : ['id','app_id','app_name'],
        autoLoad:true,
        proxy: {
            type: 'ajax',
            method: 'GET',
            url: '/apps/combo_store',
            reader: {
                type: 'json'
            },
            simpleSortMode: true,
            listeners:{
                'exception':function( theproxy, response, operation, options ){
                    var data = eval("("+response.responseText+")");
                    if(!data.success){
                        Ext.Msg.alert('信息提示',data.msg);
                    } else {
                        Ext.Msg.alert("信息提示","系统忙，请稍候再试");
                    }
                }
            }
        }
    });

    var appStore_form = Ext.create('Ext.data.JsonStore',{
        fields : ['id','app_id','app_name'],
        autoLoad:true,
        proxy: {
            type: 'ajax',
            method: 'GET',
            url: '/apps/combo_store_form',
            reader: {
                type: 'json'
            },
            simpleSortMode: true,
            listeners:{
                'exception':function( theproxy, response, operation, options ){
                    var data = eval("("+response.responseText+")");
                    if(!data.success){
                        Ext.Msg.alert('信息提示',data.msg);
                    } else {
                        Ext.Msg.alert("信息提示","系统忙，请稍候再试");
                    }
                }
            }
        }
    });
    
    var apps = getApps();
    var vendors = getDict('vendor');
    //var dictStore = getDictStore('vendor');

    var grid = Ext.create('Ext.grid.Panel', {
        id:'my_grid',
        store: store,
        loadMask: true,
        region: 'center',
        selModel: Ext.create('Ext.selection.CheckboxModel'),
        columns: [
            {
                text: "规则ID",
                dataIndex: 'id',
                hidden: true
            },{
                text:'规则编码',
                dataIndex:'rule_id'
            },{
                text: '规则名称',
                dataIndex:'rule_name'
            },{
                text:'规则类型',
                dataIndex:'rule_type',
                renderer: function(val) {
                    if(val == '1')
                        return '积分产生';
                    else if (val == '2')
                        return '积分消耗';
                    else if (val == '3')
                        return '积分惩罚';
                    else
                        return '过期积分清除';
                }
            },{
                text:'成本方',
                dataIndex:'vendor',
                renderer: function(val) {
                    return vendors[val];
                }
            },{
                text:'产品线',
                dataIndex:'app_id',
                renderer: function(val) {
                    return apps[val];
                }
            },{
                text:'积分数量',
                dataIndex:'amount'
            },{
                text:'规则开始日期',
                dataIndex:'begin_date',
                renderer: function(val) {
                    return moment(val).format('YYYY-MM-DD');
                }
            },{
                text:'规则结束日期',
                dataIndex:'end_date',
                renderer: function(val) {
                    return moment(val).format('YYYY-MM-DD');
                }
            },{
                text:'积分过期日期',
                dataIndex:'expiry_date',
                renderer: function(val) {
                    if(val) {
                        return moment(val).format('YYYY-MM-DD');    
                    } else {
                        return '';
                    }
                    
                }
            },{
                text:'积分有效天数',
                dataIndex:'period_day'
            },{
                text:'规则状态',
                dataIndex: 'status',
                renderer: function(val) {
                    if(val==0 || val=='0')
                        return "<span style='color:green;'>生效</span>";
                    else if(val==1 || val=='1')
                        return "<span style='color:red;'>失效</span>";
                    else if(val==2 || val=='2')
                        return "<span style='color:red;'>已删除</span>";
                }
            },{
                text:'规则创建日期',
                dataIndex: 'create_at',
                renderer: function(val) {
                    return moment(val).format('YYYY-MM-DD');
                }
            }
        ],
        bbar: Ext.create('Ext.PagingToolbar', {
            store: store,
            displayInfo: true,
            displayMsg: '当前显示  {0} - {1} 共  {2} 条',
            emptyMsg: "没有数据显示！",
            beforePageText: "页码",
            afterPageText: "共 {0} 页",
            firstText:"首页",
            lastText:"末页",
            nextText:"下一页",
            prevText:"上一页",
            refreshText:"刷新"
        }),
        tbar: [
            {
                icon : '../../img/add.png',
                text: "添  加",
                handler: addHandler
            },{
                icon : '../../img/edit.png',
                text: "修  改",
                handler: updHandler
            },{
                icon : '../../img/delete.png',
                text:'删  除',
                handler: function(){
                    delHandler('2');
                }
            },{
                icon : '../../img/exclamation.gif',
                text : '立即失效',
                handler : function(){
                    delHandler('1');
                }
            },{
                icon : '../../img/drop-yes.gif',
                text : '立即生效',
                handler : function(){
                    delHandler('0');
                }
            },{
                xtype:'textfield',
                labelAlign:'right',
                labelWidth:60,
                width:200,
                fieldLabel: '规则名称',
                emptyText:'请输入规则名称',
                id:'search_rule_name'
            },{
                xtype:'combo',
                fieldLabel:'产品线',
                emptyText:'请选择产品线',
                labelAlign:'right',
                id:'search_app_name',
                queryParam: 'app_name',
                minChars: 2,
                editable:false,
                store: appStore_search,
                queryMode: 'remote',
                labelWidth:60,
                width:200,
                displayField: 'app_name',
                valueField: 'app_id'
            },{
                text: '搜  索',
                icon : '../../img/search.png',
                handler: doSearch
            }
        ],
        listeners:{
            'itemdblclick': function(view, record, item, index, e, eOpts) {
                updHandler();
            }
        }
    });
    store.loadPage(1);
    
    function doSearch() {
        var params  = {};
        params.rule_name = Ext.String.trim(Ext.getCmp('search_rule_name').getValue()) ;
        params.app_id = Ext.getCmp('search_app_name').getValue();
        var proxy = store.getProxy();
        proxy.extraParams = params;
        store.loadPage(1);
    }

    var viewport = Ext.create('Ext.Viewport', {
        id: 'border-example',
        layout: 'fit',
        items: grid
    });
    
    var addWin;
    var form;
    form = new Ext.FormPanel({
        id: 'myForm',
        method:'POST',
        frame:true,
        style:'border-width:0 0 0 0;',
        bodyBorder:false,
        bodyPadding: '10 80 0 0',
        layout: 'form',
        autoScroll: true,
        plugins: {
            ptype: 'datatip'
        },
        defaults:{
            labelAlign:'right',
            labelWidth:130
        },
        items: [
            {
                xtype:'hidden',
                name:'id'
            },{
                xtype:'hidden',
                name:'create_at'
            },{
                xtype:'hidden',
                name:'priority'
            },{
                xtype:'hidden',
                name:'status'
            },{
                xtype:'textfield',
                fieldLabel:'规则编码',
                emptyText:'必填项',
                name:'rule_id',
                labelAlign: 'right',
                maxLength:35,
                allowBlank:false,
                //tooltip:'请输入规则ID/编码',
                validator:function(){
                    var _value = this.getValue();
                    var _flag = true;
                    //仅添加时才验证
                    //alert(form.getForm().url);
                    if(form.getForm().url=='/rule/add'){
                        Ext.Ajax.request({
                            async:false,
                            url: '/rule/check_rule_id?rule_id='+_value,
                            method : 'GET',
                            scope : this,// 如果通过 ajax 访问后台数据记得要加 async:false 同步
                            success: function(response, opts) {
                                var data = eval("("+response.responseText+")");
                                _flag = data.success;
                            },
                            failure: function(response, opts) {
                                var data = eval("("+response.responseText+")");
                                if(!data.success){
                                    Ext.Msg.alert('信息提示',data.msg);
                                } else {
                                    Ext.Msg.alert("信息提示","系统忙，请稍候再试");
                                }
                            }
                        });
                        if (!_flag) {
                            return true;
                        } else {
                            //this.markInvalid("此编码已经存在！");
                            //Ext.Msg.alert('错误提示', '此编码已经存在！');
                            return "此编码已经存在！";
                        }
                    } else {
                        return true;
                    }
                }
            },{
                xtype:'textfield',
                fieldLabel:'规则名称',
                emptyText:'必填项',
                name:'rule_name',
                labelAlign: 'right',
                maxLength:35,
                allowBlank:false,
                tooltip:'请输入规则名称'
            },{
                xtype:'combo',
                fieldLabel:'应用选择',
                emptyText:'必选项',
                allowBlank:false,
                name:'app_id',
                editable:false,
                store: appStore_form,
                queryMode: 'remote',
                width:80,
                displayField: 'app_name',
                valueField: 'app_id',
                listeners:{
                    'expand': function(field, eOpts) {
                        this.getStore().reload();
                    }
                }
            },{
                xtype:'combo',
                fieldLabel:'发行/成本方',
                emptyText:'必选项',
                editable:false,
                allowBlank:false,
                name:'vendor',
                store: Ext.create('Ext.data.JsonStore',{
                    fields : ['key_code','key_name'],
                    autoLoad:true,
                    proxy: {
                        type: 'ajax',
                        method: 'GET',
                        url: '/dict/list_by_keycode?key_code=vendor',
                        reader: {
                            type: 'json'
                        },
                        simpleSortMode: true,
                        listeners:{
                            'exception':function( theproxy, response, operation, options ){
                                var data = eval("("+response.responseText+")");
                                if(!data.success){
                                    Ext.Msg.alert('信息提示',data.msg);
                                } else {
                                    Ext.Msg.alert("信息提示","系统忙，请稍候再试");
                                }
                            }
                        }
                    }
                }),
                queryMode: 'remote',
                width:80,
                displayField: 'key_name',
                valueField: 'key_code',
                listeners:{
                    'expand': function(field, eOpts) {
                        this.getStore().reload();
                    }
                }
            },{
                xtype: 'container',
                layout:{
                    type:'hbox'
                },
                defaults:{
                    labelAlign: 'right'
                },
                style: {marginTop: '3px',marginLeft: '45px'},
                items:[
                    {
                        xtype : 'datefield',
                        name : 'begin_date',
                        fieldLabel : '规则开始日期',
                        emptyText:'必填项',
                        labelWidth : 85,
                        allowBlank:false,
                        format : 'Y-m-d'
                    },{
                        xtype : 'datefield',
                        name : 'end_date',
                        fieldLabel : '规则结束日期',
                        emptyText:'必填项',
                        labelWidth : 124,
                        allowBlank:false,
                        minValue: new Date(),
                        format : 'Y-m-d'
                    }
                ]
            },{
                xtype: 'container',
                layout:{
                    type:'hbox'
                },
                defaults:{
                    labelAlign: 'right'
                },
                style: {marginTop: '3px',marginLeft: '20px'},
                items:[
                    {
                        xtype: 'radiogroup',
                        fieldLabel: '积分有效期配置',
                        labelWidth:110, 
                        vertical: true,
                        id:'expiry_type',
                        listeners:{
                            'change': function (radio, newV, oldV, e) {
                                var value = newV.expiry_type;
                                if(value == '1') {
                                    form.form.findField('period_day').setValue('');
                                    form.form.findField('period_day').setEditable(false);
                                    form.form.findField('period_day').setReadOnly(true);
                                    form.form.findField('expiry_date').setValue('');
                                    form.form.findField('expiry_date').setEditable(true);
                                    form.form.findField('expiry_date').setReadOnly(false);
                                    form.form.findField('expiry_date').focus();
                                } else if (value == '2') {
                                    form.form.findField('expiry_date').setValue('');
                                    form.form.findField('expiry_date').setEditable(false);
                                    form.form.findField('expiry_date').setReadOnly(true);
                                    form.form.findField('period_day').setValue('');
                                    form.form.findField('period_day').setEditable(true);
                                    form.form.findField('period_day').setReadOnly(false);
                                    form.form.findField('period_day').focus();
                                } else {
                                    form.form.findField('expiry_date').setValue('');
                                    form.form.findField('expiry_date').setEditable(false);
                                    form.form.findField('expiry_date').setReadOnly(true);
                                    form.form.findField('period_day').setValue('');
                                    form.form.findField('period_day').setEditable(false);
                                    form.form.findField('period_day').setReadOnly(true);
                                }
                            }
                        },
                        items: [
                            {
                                boxLabel: '积分过期日期',
                                name: 'expiry_type',
                                id: 'expiry_type_1',
                                inputValue: '1',
                                width:150
                            }, {
                                boxLabel: '积分有效天数',
                                name: 'expiry_type',
                                id: 'expiry_type_2',
                                width:150,
                                inputValue: '2'
                            }, {
                                boxLabel: '下年最后一天',
                                name: 'expiry_type',
                                id: 'expiry_type_3',
                                width:150,
                                inputValue: '3'
                            }
                        ]
                    }
                ]
             },{
                xtype: 'container',
                layout:{
                    type:'hbox'
                },
                defaults:{
                    labelAlign: 'right'
                },
                style: {marginTop: '3px',marginLeft: '45px'},
                items:[
                    {
                        xtype : 'datefield',
                        name: 'expiry_date',
                        fieldLabel : '积分过期日期',
                        labelWidth : 85,
                        format : 'Y-m-d',
                        minValue: new Date()
                    },{
                        xtype : 'numberfield',
                        name:'period_day',
                        editable:false,
                        fieldLabel : '积分有效天数',
                        allowDecimals:false,
                        minValue:0,
                        labelWidth : 124,
                    }
                ]
            },{
                xtype: 'container',
                layout:{
                    type:'hbox'
                },
                defaults:{
                    labelAlign: 'right'
                },
                style: {marginTop: '3px',marginLeft: '45px'},
                items:[
                    {
                        xtype : 'numberfield',
                        name:'amount',
                        fieldLabel : '设置积分数量',
                        emptyText:'必填项',
                        allowDecimals:false,
                        labelAlign:'right',
                        minValue:0,
                        labelWidth : 85,
                        allowBlank: false
                    },{
                        xtype : 'numberfield',
                        name:'max_amount',
                        fieldLabel : '规则允许用户产生的最大积分数量',
                        allowDecimals:false,
                        labelAlign:'right',
                        minValue:0,
                        labelWidth : 240,
                        width:420,
                        allowBlank: true
                    }
                ]
            },{
                xtype: 'container',
                layout:{
                    type:'hbox'
                },
                defaults:{
                    labelAlign: 'right'
                },
                style: {marginTop: '3px',marginLeft: '45px'},
                items:[
                    {
                        xtype : 'numberfield',
                        name:'frequency',
                        fieldLabel : '设置积分频率',     
                        emptyText:'必填项',                   
                        labelWidth : 85,
                        allowBlank: false,
                        allowDecimals: false
                    },{
                        xtype: 'radiogroup',
                        fieldLabel: '频率单位',
                        vertical: true,
                        labelWidth : 98,
                        id:'frequency_unit',
                        items: [
                            {
                                boxLabel: '有效期内',
                                width:85,
                                name: 'frequency_unit',
                                id:'frequency_unit_p',
                                inputValue: 'p',
                                checked:true
                            },{
                                boxLabel: '天',
                                width:50,
                                name: 'frequency_unit',
                                id:'frequency_unit_d',
                                inputValue: 'd'
                            }, {
                                boxLabel: '周',
                                width:50,
                                name: 'frequency_unit',
                                id:'frequency_unit_w',
                                inputValue: 'w'
                            }, {
                                boxLabel: '月',
                                width:50,
                                name: 'frequency_unit',
                                id:'frequency_unit_m',
                                inputValue: 'm'
                            }, {
                                boxLabel: '年',
                                width:50,
                                name: 'frequency_unit',
                                id:'frequency_unit_y',
                                inputValue: 'y'
                            }
                        ]
                    }
                ]
            },{
                xtype: 'radiogroup',
                fieldLabel: '积分类型',
                vertical: true,
                hidden: true,
                id:'rule_type',
                items: [
                    {
                        boxLabel: '积分产生',
                        name: 'rule_type',
                        id: 'rule_type_1',
                        inputValue: '1',
                        checked: true
                    }, {
                        boxLabel: '积分消耗',
                        name: 'rule_type',
                        id: 'rule_type_2',
                        inputValue: '2'
                    }, {
                        boxLabel: '积分惩罚',
                        name: 'rule_type',
                        id: 'rule_type_3',
                        inputValue: '3'
                    }, {
                        boxLabel: '过期积分清除',
                        name: 'rule_type',
                        id: 'rule_type_4',
                        inputValue: '4'
                    }
                ]
            },
            // {
            //     xtype: 'radiogroup',
            //     fieldLabel: '规则优先级',
            //     vertical: true,
            //     id:'priority',
            //     items: [
            //         {
            //             boxLabel: '从小到大',
            //             name: 'priority',
            //             inputValue: '1'
            //         }, {
            //             boxLabel: '从高到低',
            //             name: 'priority',
            //             inputValue: '2'
            //         }
            //     ]
            // },
            {
                xtype: 'radiogroup',
                fieldLabel: '规则进入条件类型',
                vertical: true,
                id:'cond_type',
                items: [
                    {
                        boxLabel: '简单规则',
                        name: 'cond_type',
                        id: 'cond_type_0',
                        inputValue: '0',
                        checked:true
                    }, {
                        boxLabel: '复合规则',
                        name: 'cond_type',
                        id: 'cond_type_1',
                        inputValue: '1'
                    }
                ]
            },{
                xtype:'textfield',
                fieldLabel:'用户提示',
                name:'prompt',
                labelAlign: 'right',
                maxLength:300,
                tooltip:'请输入用户提示'
            },{
                xtype:'textarea',
                fieldLabel:'规则说明',
                name:'remark',
                labelAlign: 'right',
                maxLength:300,
                tooltip:'请输入规则说明'
            },{
                xtype:'textarea',
                fieldLabel:'复合规则执行内容',
                name:'condition',
                labelAlign: 'right',
                maxLength:500,
                tooltip:'当用户选择的规则进入条件类型是复合规则时，此项必填'
                //emptyText:'当用户选择的规则进入条件类型是复合规则时，此项必填'
            },{
                xtype:'textarea',
                fieldLabel:'规则扩展信息（JSON）',
                name:'meta',
                labelAlign: 'right',
                maxLength:500,
                tooltip:'请使用json格式的字符串表达'
            },{
                xtype:'textarea',
                fieldLabel:'规则修改操作日志',
                name:'command',
                id:'command',
                labelAlign: 'right',
                hidden: true,
                maxLength:35,
                tooltip:'请输入修改日志'
            }
        ],
        buttons:[{ 
            text:'保  存',
            icon:'../../img/accept.png',
            handler:function(){
                if(!form.getForm().isValid()){
                     Ext.Msg.alert('信息提示','请检查输入项是否按要求填写！');
                     return;
                }
                if(Ext.String.trim(form.form.findField('rule_name').getValue()).length == 0){
                    Ext.Msg.alert('信息提示','请输入规则名称！',function(){
                        form.form.findField('rule_name').setValue('');
                        form.form.findField('rule_name').focus();
                    });
                    return;
                }
                if(Ext.String.trim(form.form.findField('rule_id').getValue()).length == 0){
                    Ext.Msg.alert('信息提示','请输入规则ID/编码！',function(){
                        form.form.findField('rule_id').setValue('');
                        form.form.findField('rule_id').markInvalid("请输入规则ID/编码！");
                        form.form.findField('rule_id').focus();
                    });
                    return;
                }
                var begin_date = moment(form.form.findField('begin_date').getValue()).format('YYYYMMDD');
                var end_date = moment(form.form.findField('end_date').getValue()).format('YYYYMMDD');
                //规则结束日期不能小于当前日期
                if(parseInt(end_date) < parseInt(moment(new Date()).format('YYYYMMDD'))) {
                    Ext.Msg.alert('信息提示','规则结束日期不能小于当前日期！',function(){
                        form.form.findField('end_date').markInvalid("规则结束日期不能小于当前日期！");
                        form.form.findField('end_date').focus();
                    });
                    return;
                }
                //规则结束日期 不能 小于规则开始日期
                if(parseInt(end_date) < parseInt(begin_date)){
                    Ext.Msg.alert('信息提示','规则结束日期不能小于开始日期！',function(){
                        form.form.findField('end_date').markInvalid("规则结束日期不能小于开始日期！");
                        form.form.findField('end_date').focus();
                    });
                    return;
                }
                //判断积分结束日期配置
                var expiry_type = form.form.findField('expiry_type').getValue().expiry_type;
                //alert('expiry_type='+expiry_type);
                if(expiry_type == '1') {
                    //按积分结束日期配置，所以结束日期必填
                    var expiry_date_ = form.form.findField('expiry_date').getValue();
                    if(Ext.isEmpty(expiry_date_)) {
                        Ext.Msg.alert('信息提示','积分结束日期不能为空！',function(){
                            form.form.findField('expiry_date').markInvalid("积分结束日期不能为空！");
                            form.form.findField('expiry_date').focus();
                        });
                        return;
                    }
                } else if (expiry_type == '2') {
                    //按积分有效天数配置，所以有效天数必填
                    var period_day = form.form.findField('period_day').getValue();
                    if(Ext.isEmpty(period_day)) {
                        Ext.Msg.alert('信息提示','积分有效天数不能为空！',function(){
                            form.form.findField('period_day').markInvalid("积分有效天数不能为空！");
                            form.form.findField('period_day').focus();
                        });
                        return;
                    }
                } //else if (expiry_type == '3') {
                    //按下一年最后一天配置，积分结束日期和有效天数都设置为空
                //}
                //积分结束日期不能小于当前日期
                var expiry_date = moment(form.form.findField('expiry_date').getValue()).format('YYYYMMDD');
                if(parseInt(expiry_date) < parseInt(moment(new Date()).format('YYYYMMDD'))) {
                    Ext.Msg.alert('信息提示','积分结束日期不能小于当前日期！',function(){
                        form.form.findField('expiry_date').markInvalid("积分结束日期不能小于当前日期！");
                        form.form.findField('expiry_date').focus();
                    });
                    return;
                }
                //积分结束日期不能小于规则开始日期
                if(parseInt(expiry_date) < parseInt(begin_date)) {
                    Ext.Msg.alert('信息提示','积分结束日期不能小于规则开始日期！',function(){
                        form.form.findField('expiry_date').markInvalid("积分结束日期不能小于规则开始日期！");
                        form.form.findField('expiry_date').focus();
                    });
                    return;
                }
                var rule_type = form.form.findField('rule_type').getValue().rule_type;
                if(!rule_type) {
                    Ext.Msg.alert('信息提示','请设置积分类型！',function(){
                        form.form.findField('rule_type').getValue().focus();
                    });
                    return;
                }
                var cond_type = form.form.findField('cond_type').getValue().cond_type;
                if(cond_type == '1') {
                    //判断是否输入了符合规则内容
                    var condition = form.form.findField('condition').getValue();
                    if(Ext.String.trim(condition).length == 0) {
                        Ext.Msg.alert('信息提示','请输入复合规则执行的内容！',function(){
                            form.form.findField('condition').markInvalid("请输入复合规则执行的内容！");
                            form.form.findField('condition').focus();
                        });
                        return;
                    }
                }
                if(form.getForm().url == '/rule/edit') {
                    var command = form.form.findField('command').getValue();
                    if(Ext.String.trim(command).length == 0) {
                        Ext.Msg.alert('信息提示','请输入规则修改操作日志！',function(){
                            form.form.findField('command').markInvalid("请输入规则修改操作日志！");
                            form.form.findField('command').focus();
                        });
                        return;
                    }
                }
                //验证规则的拓展信息
                var meta = form.form.findField('meta').getValue();
                if(Ext.String.trim(meta).length > 0) {
                    try{
                        var obj = Ext.JSON.decode(meta);
                    } catch(e) {
                        Ext.Msg.alert('信息提示','请检查规则拓展信息，输入内容必须使用标准JSON格式！',function() {
                            form.form.findField('meta').markInvalid("输入内容请使用标准JSON格式！");
                            form.form.findField('meta').focus();
                        });
                        return;
                    }
                }
                form.form.submit({
                    waitMsg:'正在保存数据...',
                    success:function(form,action){
                        //console.log('success: '+action);
                        if(action.result.success){
                            Ext.Msg.alert('信息提示',action.result.msg,function(){
                                store.reload();
                                Ext.getCmp('myForm').getForm().reset();
                                addWin.close();
                            });
                        } else {
                            Ext.Msg.alert('信息提示',action.result.msg);
                        }
                    },
                    failure:function(thForm,action){
                        //console.log('action.result.success: '+action.result.success);
                        if(!action.result.success){
                            if(action.result.error_no == '23505') {
                                Ext.Msg.alert('信息提示', '规则ID/编码已经存在！',function() {
                                    form.form.findField('rule_id').focus();
                                });
                                return;
                            } else {
                                Ext.Msg.alert('信息提示', action.result ? action.result.msg : '操作失败');
                            }                            
                        } else {
                            Ext.Msg.alert('信息提示','操作失败，请重试！');
                        }
                    }
                });
            }
        },{
            text:'关  闭',
            icon:'../../img/close.png',
            handler:function(){
                this.up('form').getForm().reset();
                addWin.close();
            }
        }]
    });
    
    function updHandler(){
        var records = grid.getSelectionModel().getSelection();
        if(records.length > 1){
            Ext.Msg.alert("信息提示","只能选择一条数据进行修改！");
            return;
        } 
        if(records.length == 0){
            Ext.Msg.alert("信息提示","请选择需要修改的数据！");
            return;
        }
        form.form.reset();
        if(!addWin){
            addWin = Ext.create('Ext.Window', {
                title: '修改规则',
                width: 785,
                height: 560,
                modal: true,
                constrainHeader: true,
                closeAction:'hide',
                layout: 'fit',
                items: form
            });
        } else {
            addWin.setTitle('修改规则');
        }
        form.getForm().url='/rule/edit';
        Ext.Ajax.request({
            url: '/rule/detail',
            params : {'id' : records[0].get('id')},
            method : 'get',
            success: function(response, opts) {
                var jsonResult = Ext.decode(response.responseText); 
                if(jsonResult.success == false){
                    return alert(jsonResult.error || jsonResult.msg);
                }
                if(!jsonResult){
                    return ;
                }
                for(var i in jsonResult){
                    if(form.form.findField(i)){
                        form.form.findField(i).setValue(jsonResult[i]);
                    }
                }
                //设置时间
                if(jsonResult.begin_date){
                    form.form.findField('begin_date').setValue(moment(jsonResult.begin_date).format('YYYY-MM-DD'));
                }
                if(jsonResult.end_date){
                    form.form.findField('end_date').setValue(moment(jsonResult.end_date).format('YYYY-MM-DD'));
                }
                //设置积分结束日期配置项
                console.log(Ext.isEmpty(jsonResult.expiry_date) + '   ' + Ext.isEmpty(jsonResult.period_day));
                if(Ext.isEmpty(jsonResult.expiry_date) && Ext.isEmpty(jsonResult.period_day)) {
                    console.log('选择第三个');
                    Ext.getCmp('expiry_type').getComponent('expiry_type_3').setValue(true);
                }
                if(Ext.isEmpty(jsonResult.expiry_date) && !Ext.isEmpty(jsonResult.period_day)) {
                    console.log('选择第二个');
                    Ext.getCmp('expiry_type').getComponent('expiry_type_2').setValue(true);
                    form.form.findField('period_day').setValue(jsonResult.period_day);
                } 
                if(!Ext.isEmpty(jsonResult.expiry_date) && Ext.isEmpty(jsonResult.period_day)) {
                    console.log('选择第一个');
                    Ext.getCmp('expiry_type').getComponent('expiry_type_1').setValue(true);
                    form.form.findField('expiry_date').setValue(moment(jsonResult.expiry_date).format('YYYY-MM-DD'));
                }
                if(jsonResult.expiry_date) {
                    form.form.findField('expiry_date').setValue(moment(jsonResult.expiry_date).format('YYYY-MM-DD'));
                }
                //设置单选框
                if(jsonResult.frequency_unit) {
                    Ext.getCmp('frequency_unit').getComponent('frequency_unit_'+jsonResult.frequency_unit).setValue(true);
                }
                if(jsonResult.rule_type) {
                    Ext.getCmp('rule_type').getComponent('rule_type_'+jsonResult.rule_type).setValue(true);
                }
                if(jsonResult.cond_type) {
                    Ext.getCmp('cond_type').getComponent('cond_type_'+jsonResult.cond_type).setValue(true);
                }
                if(Ext.getCmp('command').isHidden()){
                    Ext.getCmp('command').setVisible(true);
                }
                form.setHeight(580);
                addWin.show();
            }
        });
    }
    
    function addHandler(){
        if(!addWin){
            addWin = Ext.create('Ext.Window', {
                title: '添加规则',
                width: 785,
                height: 560,
                bodyPadding: '0 0 0',
                'z-index': 9999999,
                constrainHeader: true,
                layout: 'fit',
                modal: true,
                closeAction:'hide',
                items: form
            });
        } else {
            addWin.setTitle('添加规则');
        }
        form.getForm().url='/rule/add';
        if(!Ext.getCmp('command').isHidden()){
            Ext.getCmp('command').setVisible(false);
        }
        //默认下年最后一天
        Ext.getCmp('expiry_type').getComponent('expiry_type_3').setValue(true);
        addWin.show();
    }

    //设置生效、失效和删除
    function delHandler(status){
        var records = grid.getSelectionModel().getSelection();
        var msg1, msg2;
        if(status == '0') {
            msg1 = "请选择一条需要立即生效的规则！";
            msg2 = "确认立即生效吗？";
        } else if (status == '1') {
            msg1 = "请选择一条需要立即失效的规则";
            msg2 = "确认立即失效吗？";
        } else if (status == '2') {
            msg1 = "请选择一条需要删除的规则";
            msg2 = "确认删除此规则吗？";
        }
        if(records.length == 0){
            Ext.Msg.alert("信息提示", msg1);
            return;
        }
        if(records.length > 1){
            Ext.Msg.alert('信息提示', '不允许批量操作！');
            return;
        }
        var status_now = records[0].get('status');
        if(status == status_now) {
            Ext.Msg.alert('信息提示', '该规则当前状态不支持此操作！');
            return;
        }
        Ext.MessageBox.confirm('信息提示',msg2,function(val){
            if(val == 'yes'){
                Ext.Ajax.request({
                    url: '/rule/status?id='+records[0].get("id")+'&status='+status,
                    method : 'POST',
                    success: function(response, opts) {
                        var data = eval("("+response.responseText+")");
                        Ext.Msg.alert('信息提示', data.msg, function() {
                            window.location.reload();
                        });
                        //store.reload();
                    },
                    failure: function(response, opts) {
                        var data = eval("("+response.responseText+")");
                        if(!data.success){
                            Ext.Msg.alert('信息提示',data.msg || data.error);
                        } else {
                            Ext.Msg.alert("信息提示","系统忙，请稍候再试");
                        }
                    }
                });
            }
        });
    }
});
</script>
<body>
</body>
</html>